home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Magazine / GraphicsCards / StormMesa / src / depth.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-02-04  |  17.5 KB  |  879 lines
  1. /* $Id: depth.c,v 3.4 1998/08/23 22:17:42 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.0
  6.  * Copyright (C) 1995-1998  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: depth.c,v $
  26.  * Revision 3.4  1998/08/23 22:17:42  brianp
  27.  * moved gl_DepthRange() to matrix.c
  28.  *
  29.  * Revision 3.3  1998/06/01 00:35:13  brianp
  30.  * don't clear depth buffer if depth buffer write mask is false
  31.  *
  32.  * Revision 3.2  1998/03/27 03:39:14  brianp
  33.  * fixed G++ warnings
  34.  *
  35.  * Revision 3.1  1998/02/08 20:18:41  brianp
  36.  * removed unneeded headers
  37.  *
  38.  * Revision 3.0  1998/01/31 20:50:23  brianp
  39.  * initial rev
  40.  *
  41.  */
  42.  
  43.  
  44. /*
  45.  * Depth buffer functions
  46.  */
  47.  
  48.  
  49. #ifdef PC_HEADER
  50. #include "all.h"
  51. #else
  52. #include <stdlib.h>
  53. #include <string.h>
  54. #include "context.h"
  55. #include "depth.h"
  56. #include "macros.h"
  57. #include "types.h"
  58. #endif
  59.  
  60.  
  61.  
  62. /**********************************************************************/
  63. /*****                          API Functions                     *****/
  64. /**********************************************************************/
  65.  
  66.  
  67.  
  68. void gl_ClearDepth( GLcontext* ctx, GLclampd depth )
  69. {
  70.    if (INSIDE_BEGIN_END(ctx)) {
  71.       gl_error( ctx, GL_INVALID_OPERATION, "glClearDepth" );
  72.       return;
  73.    }
  74.    ctx->Depth.Clear = (GLfloat) CLAMP( depth, 0.0, 1.0 );
  75. }
  76.  
  77.  
  78.  
  79. void gl_DepthFunc( GLcontext* ctx, GLenum func )
  80. {
  81.    if (INSIDE_BEGIN_END(ctx)) {
  82.       gl_error( ctx, GL_INVALID_OPERATION, "glDepthFunc" );
  83.       return;
  84.    }
  85.  
  86.    switch (func) {
  87.       case GL_NEVER:
  88.       case GL_LESS:    /* (default) pass if incoming z < stored z */
  89.       case GL_GEQUAL:
  90.       case GL_LEQUAL:
  91.       case GL_GREATER:
  92.       case GL_NOTEQUAL:
  93.       case GL_EQUAL:
  94.       case GL_ALWAYS:
  95.      ctx->Depth.Func = func;
  96.      ctx->NewState |= NEW_RASTER_OPS;
  97.      break;
  98.       default:
  99.      gl_error( ctx, GL_INVALID_ENUM, "glDepth.Func" );
  100.    }
  101. }
  102.  
  103.  
  104.  
  105. void gl_DepthMask( GLcontext* ctx, GLboolean flag )
  106. {
  107.    if (INSIDE_BEGIN_END(ctx)) {
  108.       gl_error( ctx, GL_INVALID_OPERATION, "glDepthMask" );
  109.       return;
  110.    }
  111.  
  112.    /*
  113.     * GL_TRUE indicates depth buffer writing is enabled (default)
  114.     * GL_FALSE indicates depth buffer writing is disabled
  115.     */
  116.    ctx->Depth.Mask = flag;
  117.    ctx->NewState |= NEW_RASTER_OPS;
  118. }
  119.  
  120.  
  121.  
  122. /**********************************************************************/
  123. /*****                   Depth Testing Functions                  *****/
  124. /**********************************************************************/
  125.  
  126.  
  127. /*
  128.  * Depth test horizontal spans of fragments.  These functions are called
  129.  * via ctx->Driver.depth_test_span only.
  130.  *
  131.  * Input:  n - number of pixels in the span
  132.  *         x, y - location of leftmost pixel in span in window coords
  133.  *         z - array [n] of integer depth values
  134.  * In/Out:  mask - array [n] of flags (1=draw pixel, 0=don't draw) 
  135.  * Return:  number of pixels which passed depth test
  136.  */
  137.  
  138. /*
  139.  * glDepthFunc( any ) and glDepthMask( GL_TRUE or GL_FALSE ).
  140.  */
  141. GLuint gl_depth_test_span_generic( GLcontext* ctx,
  142.                    GLuint n, GLint x, GLint y,
  143.                    const GLdepth z[],
  144.                    GLubyte mask[] )
  145. {
  146.    GLdepth *zptr = Z_ADDRESS( ctx, x, y );
  147.    GLubyte *m = mask;
  148.    GLuint i;
  149.    GLuint passed = 0;
  150.    /* switch cases ordered from most frequent to less frequent */
  151.    switch (ctx->Depth.Func) {
  152.       case GL_LESS:
  153.      if (ctx->Depth.Mask) {
  154.         /* Update Z buffer */
  155.         for (i=0; i<n; i++,zptr++,m++) {
  156.            if (*m) {
  157.           if (z[i] < *zptr) {
  158.              /* pass */
  159.              *zptr = z[i];
  160.              passed++;
  161.           }
  162.           else {
  163.              /* fail */
  164.              *m = 0;
  165.           }
  166.            }
  167.         }
  168.      }
  169.      else {
  170.         /* Don't update Z buffer */
  171.         for (i=0; i<n; i++,zptr++,m++) {
  172.            if (*m) {
  173.           if (z[i] < *zptr) {
  174.              /* pass */
  175.              passed++;
  176.           }
  177.           else {
  178.              *m = 0;
  179.           }
  180.            }
  181.         }
  182.      }
  183.      break;
  184.       case GL_LEQUAL:
  185.      if (ctx->Depth.Mask) {
  186.         /* Update Z buffer */
  187.         for (i=0;i<n;i++,zptr++,m++) {
  188.            if (*m) {
  189.           if (z[i] <= *zptr) {
  190.              *zptr = z[i];
  191.              passed++;
  192.           }
  193.           else {
  194.              *m = 0;
  195.           }
  196.            }
  197.         }
  198.      }
  199.      else {
  200.         /* Don't update Z buffer */
  201.         for (i=0;i<n;i++,zptr++,m++) {
  202.            if (*m) {
  203.           if (z[i] <= *zptr) {
  204.              /* pass */
  205.              passed++;
  206.           }
  207.           else {
  208.              *m = 0;
  209.           }
  210.            }
  211.         }
  212.      }
  213.      break;
  214.       case GL_GEQUAL:
  215.      if (ctx->Depth.Mask) {
  216.         /* Update Z buffer */
  217.         for (i=0;i<n;i++,zptr++,m++) {
  218.            if (*m) {
  219.           if (z[i] >= *zptr) {
  220.              *zptr = z[i];
  221.              passed++;
  222.           }
  223.           else {
  224.              *m = 0;
  225.           }
  226.            }
  227.         }
  228.      }
  229.      else {
  230.         /* Don't update Z buffer */
  231.         for (i=0;i<n;i++,zptr++,m++) {
  232.            if (*m) {
  233.           if (z[i] >= *zptr) {
  234.              /* pass */
  235.              passed++;
  236.           }
  237.           else {
  238.              *m = 0;
  239.           }
  240.            }
  241.         }
  242.      }
  243.      break;
  244.       case GL_GREATER:
  245.      if (ctx->Depth.Mask) {
  246.         /* Update Z buffer */
  247.         for (i=0;i<n;i++,zptr++,m++) {
  248.            if (*m) {
  249.           if (z[i] > *zptr) {
  250.              *zptr = z[i];
  251.              passed++;
  252.           }
  253.           else {
  254.              *m = 0;
  255.           }
  256.            }
  257.         }
  258.      }
  259.      else {
  260.         /* Don't update Z buffer */
  261.         for (i=0;i<n;i++,zptr++,m++) {
  262.            if (*m) {
  263.           if (z[i] > *zptr) {
  264.              /* pass */
  265.              passed++;
  266.           }
  267.           else {
  268.              *m = 0;
  269.           }
  270.            }
  271.         }
  272.      }
  273.      break;
  274.       case GL_NOTEQUAL:
  275.      if (ctx->Depth.Mask) {
  276.         /* Update Z buffer */
  277.         for (i=0;i<n;i++,zptr++,m++) {
  278.            if (*m) {
  279.           if (z[i] != *zptr) {
  280.              *zptr = z[i];
  281.              passed++;
  282.           }
  283.           else {
  284.              *m = 0;
  285.           }
  286.            }
  287.         }
  288.      }
  289.      else {
  290.         /* Don't update Z buffer */
  291.         for (i=0;i<n;i++,zptr++,m++) {
  292.            if (*m) {
  293.           if (z[i] != *zptr) {
  294.              /* pass */
  295.              passed++;
  296.           }
  297.           else {
  298.              *m = 0;
  299.           }
  300.            }
  301.         }
  302.      }
  303.      break;
  304.       case GL_EQUAL:
  305.      if (ctx->Depth.Mask) {
  306.         /* Update Z buffer */
  307.         for (i=0;i<n;i++,zptr++,m++) {
  308.            if (*m) {
  309.           if (z[i] == *zptr) {
  310.              *zptr = z[i];
  311.              passed++;
  312.           }
  313.           else {
  314.              *m =0;
  315.           }
  316.            }
  317.         }
  318.      }
  319.      else {
  320.         /* Don't update Z buffer */
  321.         for (i=0;i<n;i++,zptr++,m++) {
  322.            if (*m) {
  323.           if (z[i] == *zptr) {
  324.              /* pass */
  325.              passed++;
  326.           }
  327.           else {
  328.              *m =0;
  329.           }
  330.            }
  331.         }
  332.      }
  333.      break;
  334.       case GL_ALWAYS:
  335.      if (ctx->Depth.Mask) {
  336.         /* Update Z buffer */
  337.         for (i=0;i<n;i++,zptr++,m++) {
  338.            if (*m) {
  339.           *zptr = z[i];
  340.           passed++;
  341.            }
  342.         }
  343.      }
  344.      else {
  345.         /* Don't update Z buffer or mask */
  346.         passed = n;
  347.      }
  348.      break;
  349.       case GL_NEVER:
  350.      for (i=0;i<n;i++) {
  351.         mask[i] = 0;
  352.      }
  353.      break;
  354.       default:
  355.      gl_problem(ctx, "Bad depth func in gl_depth_test_span_generic");
  356.    } /*switch*/
  357.  
  358.    return passed;
  359. }
  360.  
  361.  
  362.  
  363. /*
  364.  * glDepthFunc(GL_LESS) and glDepthMask(GL_TRUE).
  365.  */
  366. GLuint gl_depth_test_span_less( GLcontext* ctx,
  367.                 GLuint n, GLint x, GLint y, const GLdepth z[],
  368.                 GLubyte mask[] )
  369. {
  370.    GLdepth *zptr = Z_ADDRESS( ctx, x, y );
  371.    GLuint i;
  372.    GLuint passed = 0;
  373.  
  374.    for (i=0; i<n; i++) {
  375.       if (mask[i]) {
  376.      if (z[i] < zptr[i]) {
  377.         /* pass */
  378.         zptr[i] = z[i];
  379.         passed++;
  380.      }
  381.      else {
  382.         /* fail */
  383.         mask[i] = 0;
  384.      }
  385.       }
  386.    }
  387.    return passed;
  388. }
  389.  
  390.  
  391. /*
  392.  * glDepthFunc(GL_GREATER) and glDepthMask(GL_TRUE).
  393.  */
  394. GLuint gl_depth_test_span_greater( GLcontext* ctx,
  395.                    GLuint n, GLint x, GLint y,
  396.                    const GLdepth z[],
  397.                    GLubyte mask[] )
  398. {
  399.    GLdepth *zptr = Z_ADDRESS( ctx, x, y );
  400.    GLuint i;
  401.    GLuint passed = 0;
  402.  
  403.    for (i=0; i<n; i++) {
  404.       if (mask[i]) {
  405.      if (z[i] > zptr[i]) {
  406.         /* pass */
  407.         zptr[i] = z[i];
  408.         passed++;
  409.      }
  410.      else {
  411.         /* fail */
  412.         mask[i] = 0;
  413.      }
  414.       }
  415.    }
  416.    return passed;
  417. }
  418.  
  419.  
  420.  
  421. /*
  422.  * Depth test an array of randomly positioned fragments.
  423.  */
  424.  
  425.  
  426. #define ZADDR_SETUP   GLdepth *depthbuffer = ctx->Buffer->Depth; \
  427.               GLint width = ctx->Buffer->Width;
  428.  
  429. #define ZADDR( X, Y )   (depthbuffer + (Y) * width + (X) )
  430.  
  431.  
  432.  
  433. /*
  434.  * glDepthFunc( any ) and glDepthMask( GL_TRUE or GL_FALSE ).
  435.  */
  436. void gl_depth_test_pixels_generic( GLcontext* ctx,
  437.                    GLuint n, const GLint x[], const GLint y[],
  438.                    const GLdepth z[], GLubyte mask[] )
  439. {
  440.    register GLdepth *zptr;
  441.    register GLuint i;
  442.  
  443.    /* switch cases ordered from most frequent to less frequent */
  444.    switch (ctx->Depth.Func) {
  445.       case GL_LESS:
  446.      if (ctx->Depth.Mask) {
  447.         /* Update Z buffer */
  448.         for (i=0; i<n; i++) {
  449.            if (mask[i]) {
  450.           zptr = Z_ADDRESS(ctx,x[i],y[i]);
  451.           if (z[i] < *zptr) {
  452.              /* pass */
  453.              *zptr = z[i];
  454.           }
  455.           else {
  456.              /* fail */
  457.              mask[i] = 0;
  458.           }
  459.            }
  460.         }
  461.      }
  462.      else {
  463.         /* Don't update Z buffer */
  464.         for (i=0; i<n; i++) {
  465.            if (mask[i]) {
  466.           zptr = Z_ADDRESS(ctx,x[i],y[i]);
  467.           if (z[i] < *zptr) {
  468.              /* pass */
  469.           }
  470.           else {
  471.              /* fail */
  472.              mask[i] = 0;
  473.           }
  474.            }
  475.         }
  476.      }
  477.      break;
  478.       case GL_LEQUAL:
  479.      if (ctx->Depth.Mask) {
  480.         /* Update Z buffer */
  481.         for (i=0; i<n; i++) {
  482.            if (mask[i]) {
  483.           zptr = Z_ADDRESS(ctx,x[i],y[i]);
  484.           if (z[i] <= *zptr) {
  485.              /* pass */
  486.              *zptr = z[i];
  487.           }
  488.           else {
  489.              /* fail */
  490.              mask[i] = 0;
  491.           }
  492.            }
  493.         }
  494.      }
  495.      else {
  496.         /* Don't update Z buffer */
  497.         for (i=0; i<n; i++) {
  498.            if (mask[i]) {
  499.           zptr = Z_ADDRESS(ctx,x[i],y[i]);
  500.           if (z[i] <= *zptr) {
  501.              /* pass */
  502.           }
  503.           else {
  504.              /* fail */
  505.              mask[i] = 0;
  506.           }
  507.            }
  508.         }
  509.      }
  510.      break;
  511.       case GL_GEQUAL:
  512.      if (ctx->Depth.Mask) {
  513.         /* Update Z buffer */
  514.         for (i=0; i<n; i++) {
  515.            if (mask[i]) {
  516.           zptr = Z_ADDRESS(ctx,x[i],y[i]);
  517.           if (z[i] >= *zptr) {
  518.              /* pass */
  519.              *zptr = z[i];
  520.           }
  521.           else {
  522.              /* fail */
  523.              mask[i] = 0;
  524.           }
  525.            }
  526.         }
  527.      }
  528.      else {
  529.         /* Don't update Z buffer */
  530.         for (i=0; i<n; i++) {
  531.            if (mask[i]) {
  532.           zptr = Z_ADDRESS(ctx,x[i],y[i]);
  533.           if (z[i] >= *zptr) {
  534.              /* pass */
  535.           }
  536.           else {
  537.              /* fail */
  538.              mask[i] = 0;
  539.           }
  540.            }
  541.         }
  542.      }
  543.      break;
  544.       case GL_GREATER:
  545.      if (ctx->Depth.Mask) {
  546.         /* Update Z buffer */
  547.         for (i=0; i<n; i++) {
  548.            if (mask[i]) {
  549.           zptr = Z_ADDRESS(ctx,x[i],y[i]);
  550.           if (z[i] > *zptr) {
  551.              /* pass */
  552.              *zptr = z[i];
  553.           }
  554.           else {
  555.              /* fail */
  556.              mask[i] = 0;
  557.           }
  558.            }
  559.         }
  560.      }
  561.      else {
  562.         /* Don't update Z buffer */
  563.         for (i=0; i<n; i++) {
  564.            if (mask[i]) {
  565.           zptr = Z_ADDRESS(ctx,x[i],y[i]);
  566.           if (z[i] > *zptr) {
  567.              /* pass */
  568.           }
  569.           else {
  570.              /* fail */
  571.              mask[i] = 0;
  572.           }
  573.            }
  574.         }
  575.      }
  576.      break;
  577.       case GL_NOTEQUAL:
  578.      if (ctx->Depth.Mask) {
  579.         /* Update Z buffer */
  580.         for (i=0; i<n; i++) {
  581.            if (mask[i]) {
  582.           zptr = Z_ADDRESS(ctx,x[i],y[i]);
  583.           if (z[i] != *zptr) {
  584.              /* pass */
  585.              *zptr = z[i];
  586.           }
  587.           else {
  588.              /* fail */
  589.              mask[i] = 0;
  590.           }
  591.            }
  592.         }
  593.      }
  594.      else {
  595.         /* Don't update Z buffer */
  596.         for (i=0; i<n; i++) {
  597.            if (mask[i]) {
  598.           zptr = Z_ADDRESS(ctx,x[i],y[i]);
  599.           if (z[i] != *zptr) {
  600.              /* pass */
  601.           }
  602.           else {
  603.              /* fail */
  604.              mask[i] = 0;
  605.           }
  606.            }
  607.         }
  608.      }
  609.      break;
  610.       case GL_EQUAL:
  611.      if (ctx->Depth.Mask) {
  612.         /* Update Z buffer */
  613.         for (i=0; i<n; i++) {
  614.            if (mask[i]) {
  615.           zptr = Z_ADDRESS(ctx,x[i],y[i]);
  616.           if (z[i] == *zptr) {
  617.              /* pass */
  618.              *zptr = z[i];
  619.           }
  620.           else {
  621.              /* fail */
  622.              mask[i] = 0;
  623.           }
  624.            }
  625.         }
  626.      }
  627.      else {
  628.         /* Don't update Z buffer */
  629.         for (i=0; i<n; i++) {
  630.            if (mask[i]) {
  631.           zptr = Z_ADDRESS(ctx,x[i],y[i]);
  632.           if (z[i] == *zptr) {
  633.              /* pass */
  634.           }
  635.           else {
  636.              /* fail */
  637.              mask[i] = 0;
  638.           }
  639.            }
  640.         }
  641.      }
  642.      break;
  643.       case GL_ALWAYS:
  644.      if (ctx->Depth.Mask) {
  645.         /* Update Z buffer */
  646.         for (i=0; i<n; i++) {
  647.            if (mask[i]) {
  648.           zptr = Z_ADDRESS(ctx,x[i],y[i]);
  649.           *zptr = z[i];
  650.            }
  651.         }
  652.      }
  653.      else {
  654.         /* Don't update Z buffer or mask */
  655.      }
  656.      break;
  657.       case GL_NEVER:
  658.      /* depth test never passes */
  659.      for (i=0;i<n;i++) {
  660.         mask[i] = 0;
  661.      }
  662.      break;
  663.       default:
  664.      gl_problem(ctx, "Bad depth func in gl_depth_test_pixels_generic");
  665.    } /*switch*/
  666. }
  667.  
  668.  
  669.  
  670. /*
  671.  * glDepthFunc( GL_LESS ) and glDepthMask( GL_TRUE ).
  672.  */
  673. void gl_depth_test_pixels_less( GLcontext* ctx,
  674.                 GLuint n, const GLint x[], const GLint y[],
  675.                 const GLdepth z[], GLubyte mask[] )
  676. {
  677.    GLdepth *zptr;
  678.    GLuint i;
  679.  
  680.    for (i=0; i<n; i++) {
  681.       if (mask[i]) {
  682.      zptr = Z_ADDRESS(ctx,x[i],y[i]);
  683.      if (z[i] < *zptr) {
  684.         /* pass */
  685.         *zptr = z[i];
  686.      }
  687.      else {
  688.         /* fail */
  689.         mask[i] = 0;
  690.      }
  691.       }
  692.    }
  693. }
  694.  
  695.  
  696. /*
  697.  * glDepthFunc( GL_GREATER ) and glDepthMask( GL_TRUE ).
  698.  */
  699. void gl_depth_test_pixels_greater( GLcontext* ctx,
  700.                    GLuint n, const GLint x[], const GLint y[],
  701.                    const GLdepth z[], GLubyte mask[] )
  702. {
  703.    GLdepth *zptr;
  704.    GLuint i;
  705.  
  706.    for (i=0; i<n; i++) {
  707.       if (mask[i]) {
  708.      zptr = Z_ADDRESS(ctx,x[i],y[i]);
  709.      if (z[i] > *zptr) {
  710.         /* pass */
  711.         *zptr = z[i];
  712.      }
  713.      else {
  714.         /* fail */
  715.         mask[i] = 0;
  716.      }
  717.       }
  718.    }
  719. }
  720.  
  721.  
  722.  
  723.  
  724. /**********************************************************************/
  725. /*****                      Read Depth Buffer                     *****/
  726. /**********************************************************************/
  727.  
  728.  
  729. /*
  730.  * Return a span of depth values from the depth buffer as floats in [0,1].
  731.  * This function is only called through Driver.read_depth_span_float()
  732.  * Input:  n - how many pixels
  733.  *         x,y - location of first pixel
  734.  * Output:  depth - the array of depth values
  735.  */
  736. void gl_read_depth_span_float( GLcontext* ctx,
  737.                    GLuint n, GLint x, GLint y, GLfloat depth[] )
  738. {
  739.    GLdepth *zptr;
  740.    GLfloat scale;
  741.    GLuint i;
  742.  
  743.    scale = 1.0F / DEPTH_SCALE;
  744.  
  745.    if (ctx->Buffer->Depth) {
  746.       zptr = Z_ADDRESS( ctx, x, y );
  747.       for (i=0;i<n;i++) {
  748.      depth[i] = (GLfloat) zptr[i] * scale;
  749.       }
  750.    }
  751.    else {
  752.       for (i=0;i<n;i++) {
  753.      depth[i] = 0.0F;
  754.       }
  755.    }
  756. }
  757.  
  758.  
  759. /*
  760.  * Return a span of depth values from the depth buffer as integers in
  761.  * [0,MAX_DEPTH].
  762.  * This function is only called through Driver.read_depth_span_int()
  763.  * Input:  n - how many pixels
  764.  *         x,y - location of first pixel
  765.  * Output:  depth - the array of depth values
  766.  */
  767. void gl_read_depth_span_int( GLcontext* ctx,
  768.                  GLuint n, GLint x, GLint y, GLdepth depth[] )
  769. {
  770.    if (ctx->Buffer->Depth) {
  771.       GLdepth *zptr = Z_ADDRESS( ctx, x, y );
  772.       MEMCPY( depth, zptr, n * sizeof(GLdepth) );
  773.    }
  774.    else {
  775.       GLuint i;
  776.       for (i=0;i<n;i++) {
  777.      depth[i] = 0;
  778.       }
  779.    }
  780. }
  781.  
  782.  
  783.  
  784. /**********************************************************************/
  785. /*****                Allocate and Clear Depth Buffer             *****/
  786. /**********************************************************************/
  787.  
  788.  
  789.  
  790. /*
  791.  * Allocate a new depth buffer.  If there's already a depth buffer allocated
  792.  * it will be free()'d.  The new depth buffer will be uniniitalized.
  793.  * This function is only called through Driver.alloc_depth_buffer.
  794.  */
  795. void gl_alloc_depth_buffer( GLcontext* ctx )
  796. {
  797.    /* deallocate current depth buffer if present */
  798.    if (ctx->Buffer->Depth) {
  799.       free(ctx->Buffer->Depth);
  800.       ctx->Buffer->Depth = NULL;
  801.    }
  802.  
  803.    /* allocate new depth buffer, but don't initialize it */
  804.    ctx->Buffer->Depth = (GLdepth *) malloc( ctx->Buffer->Width
  805.                         * ctx->Buffer->Height
  806.                         * sizeof(GLdepth) );
  807.    if (!ctx->Buffer->Depth) {
  808.       /* out of memory */
  809.       ctx->Depth.Test = GL_FALSE;
  810.       gl_error( ctx, GL_OUT_OF_MEMORY, "Couldn't allocate depth buffer" );
  811.    }
  812. }
  813.  
  814.  
  815.  
  816.  
  817. /*
  818.  * Clear the depth buffer.  If the depth buffer doesn't exist yet we'll
  819.  * allocate it now.
  820.  * This function is only called through Driver.clear_depth_buffer.
  821.  */
  822. void gl_clear_depth_buffer( GLcontext* ctx )
  823. {
  824.    GLdepth clear_value = (GLdepth) (ctx->Depth.Clear * DEPTH_SCALE);
  825.  
  826.    if (ctx->Visual->DepthBits==0 || !ctx->Buffer->Depth || !ctx->Depth.Mask) {
  827.       /* no depth buffer, or writing to it is disabled */
  828.       return;
  829.    }
  830.  
  831.    /* The loops in this function have been written so the IRIX 5.3
  832.     * C compiler can unroll them.  Hopefully other compilers can too!
  833.     */
  834.  
  835.    if (ctx->Scissor.Enabled) {
  836.       /* only clear scissor region */
  837.       GLint y;
  838.       for (y=ctx->Buffer->Ymin; y<=ctx->Buffer->Ymax; y++) {
  839.      GLdepth *d = Z_ADDRESS( ctx, ctx->Buffer->Xmin, y );
  840.      GLint n = ctx->Buffer->Xmax - ctx->Buffer->Xmin + 1;
  841.      do {
  842.         *d++ = clear_value;
  843.         n--;
  844.      } while (n);
  845.       }
  846.    }
  847.    else {
  848.       /* clear whole buffer */
  849.       if (sizeof(GLdepth)==2 && (clear_value&0xff)==(clear_value>>8)) {
  850.      /* lower and upper bytes of clear_value are same, use MEMSET */
  851.      MEMSET( ctx->Buffer->Depth, clear_value&0xff,
  852.          2*ctx->Buffer->Width*ctx->Buffer->Height);
  853.       }
  854.       else {
  855.      GLdepth *d = ctx->Buffer->Depth;
  856.      GLint n = ctx->Buffer->Width * ctx->Buffer->Height;
  857.      while (n>=16) {
  858.         d[0] = clear_value;    d[1] = clear_value;
  859.         d[2] = clear_value;    d[3] = clear_value;
  860.         d[4] = clear_value;    d[5] = clear_value;
  861.         d[6] = clear_value;    d[7] = clear_value;
  862.         d[8] = clear_value;    d[9] = clear_value;
  863.         d[10] = clear_value;   d[11] = clear_value;
  864.         d[12] = clear_value;   d[13] = clear_value;
  865.         d[14] = clear_value;   d[15] = clear_value;
  866.         d += 16;
  867.         n -= 16;
  868.      }
  869.      while (n>0) {
  870.         *d++ = clear_value;
  871.         n--;
  872.      }
  873.       }
  874.    }
  875. }
  876.  
  877.  
  878.  
  879.